package icu.gking.cart_system;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import icu.gking.cart_system.pojo.*;
import icu.gking.cart_system.service.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 控制台运行类，实现购物系统的主逻辑。
 */
@Slf4j
@Component
public class ConsoleRunner implements CommandLineRunner {

    @Autowired
    private CartService cartService; // 购物车服务
    @Autowired
    private CommodityService commodityService; // 商品服务
    @Autowired
    private OrdersService ordersService; // 订单服务
    @Autowired
    private OrderDetailsService orderDetailsService; // 订单详情服务
    @Autowired
    private UserService userService; // 用户服务

    private final Scanner scanner = new Scanner(System.in); // 用于读取用户输入

    /**
     * 安全读取整数输入的方法。
     * @return 用户输入的整数
     */
    private int readInt() {
        while (true) {
            try {
                return Integer.parseInt(scanner.nextLine().trim());
            } catch (NumberFormatException e) {
                System.out.println("请输入有效的数字！");
            }
        }
    }

    /**
     * 安全读取双精度数输入的方法。
     * @return 用户输入的双精度数
     */
    private double readDouble() {
        while (true) {
            try {
                return Double.parseDouble(scanner.nextLine().trim());
            } catch (NumberFormatException e) {
                System.out.println("请输入有效的数字！");
            }
        }
    }

    /**
     * 购物系统的主执行方法，处理系统的启动和退出。
     * @param args 命令行参数（未使用）
     */
    @Override
    public void run(String... args) {
        while (true) {
            try {
                System.out.println("\n=== 购物系统 ===");
                System.out.println("1. 登录");
                System.out.println("2. 注册");
                System.out.println("3. 退出");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        login(); // 调用登录方法
                        break;
                    case 2:
                        register(); // 调用注册方法
                        break;
                    case 3:
                        System.out.println("感谢使用，再见！");
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("系统错误", e);
                System.out.println("系统发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 处理用户登录逻辑。
     */
    private void login() {
        try {
            System.out.print("请输入账户名: ");
            String username = scanner.nextLine().trim();
            System.out.print("请输入密码: ");
            String password = scanner.nextLine().trim();

            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("user_name", username);
            queryWrapper.eq("password", password);

            User user = userService.getOne(queryWrapper);
            if (user == null) {
                System.out.println("用户名或密码错误。");
                return;
            }

            if (user.getStatus() != 1) {
                System.out.println("账户已被禁用。");
                return;
            }

            System.out.println("登录成功!");
            if (user.getRole() == 0) {
                buyerMenu(user.getUserId()); // 如果是买家，进入买家菜单
            } else {
                sellerMenu(user.getUserId()); // 如果是卖家，进入卖家菜单
            }
        } catch (Exception e) {
            log.error("登录错误", e);
            System.out.println("登录过程发生错误: " + e.getMessage());
        }
    }

    /**
     * 处理用户注册逻辑。
     */
    private void register() {
        try {
            User user = new User();
            System.out.print("选择注册类型 (1: 买家, 2: 商家): ");
            int roleChoice = readInt();
            if (roleChoice != 1 && roleChoice != 2) {
                System.out.println("无效的角色选择");
                return;
            }
            user.setRole(roleChoice - 1);

            System.out.print("请输入账户名: ");
            String username = scanner.nextLine().trim();
            if (username.isEmpty()) {
                System.out.println("用户名不能为空");
                return;
            }

            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("user_name", username);
            if (userService.count(queryWrapper) > 0) {
                System.out.println("用户名已存在");
                return;
            }

            System.out.print("请输入密码: ");
            String password = scanner.nextLine().trim();
            if (password.isEmpty()) {
                System.out.println("密码不能为空");
                return;
            }

            user.setUserName(username);
            user.setPassword(password);
            user.setStatus(1);

            if (userService.save(user)) {
                System.out.println("注册成功");
            } else {
                System.out.println("注册失败");
            }
        } catch (Exception e) {
            log.error("注册错误", e);
            System.out.println("注册过程发生错误: " + e.getMessage());
        }
    }

    /**
     * 买家菜单，提供各种购物操作选项。
     * @param userId 用户ID
     */
    private void buyerMenu(int userId) {
        while (true) {
            try {
                System.out.println("\n=== 买家菜单 ===");
                System.out.println("1. 查看商品列表");
                System.out.println("2. 查看购物车");
                System.out.println("3. 查看订单历史");
                System.out.println("4. 返回主菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        viewProductList(); // 查看所有商品
                        handleProductOperations(userId); // 处理商品相关操作
                        break;
                    case 2:
                        viewCart(userId); // 查看购物车
                        handleCartOperations(userId); // 处理购物车操作
                        break;
                    case 3:
                        viewOrderHistory(userId); // 查看订单历史
                        break;
                    case 4:
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("买家菜单操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 卖家菜单，提供商品和订单管理选项。
     * @param userId 用户ID
     */
    private void sellerMenu(int userId) {
        while (true) {
            try {
                System.out.println("\n=== 商家菜单 ===");
                System.out.println("1. 商品管理");
                System.out.println("2. 订单管理");
                System.out.println("3. 查看商品列表");
                System.out.println("4. 返回主菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        manageProducts(userId); // 管理商品
                        break;
                    case 2:
                        manageOrders(userId); // 管理订单
                        break;
                    case 3:
                        viewProductList(); // 查看商品列表
                        break;
                    case 4:
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("商家菜单操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 商品管理菜单，提供添加、修改和下架商品的功能。
     * @param userId 卖家ID
     */
    private void manageProducts(int userId) {
        while (true) {
            try {
                System.out.println("\n=== 商品管理 ===");
                System.out.println("1. 添加新商品");
                System.out.println("2. 修改商品信息");
                System.out.println("3. 下架商品");
                System.out.println("4. 返回上级菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        addNewProduct(userId); // 添加新商品
                        break;
                    case 2:
                        modifyProduct(userId); // 修改商品信息
                        break;
                    case 3:
                        removeProduct(userId); // 下架商品
                        break;
                    case 4:
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("商品管理操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 添加新商品到系统中。
     * @param userId 卖家ID
     */
    private void addNewProduct(int userId) {
        try {
            Commodity commodity = new Commodity();
            commodity.setSellerId(userId);

            System.out.print("请输入商品名称: ");
            String name = scanner.nextLine().trim();
            if (name.isEmpty()) {
                System.out.println("商品名称不能为空！");
                return;
            }
            commodity.setCommodityName(name);

            System.out.print("请输入商品价格: ");
            double price = readDouble();
            if (price <= 0) {
                System.out.println("价格必须大于0！");
                return;
            }
            commodity.setPrice(price);

            System.out.print("请输入商品库存: ");
            int stock = readInt();
            if (stock < 0) {
                System.out.println("库存不能为负数！");
                return;
            }
            commodity.setStock(stock);

            commodity.setStatus(1); // 设置商品状态为上架

            if (commodityService.save(commodity)) {
                System.out.println("商品添加成功！");
            } else {
                System.out.println("商品添加失败！");
            }
        } catch (Exception e) {
            log.error("添加商品错误", e);
            System.out.println("添加商品时发生错误: " + e.getMessage());
        }
    }

    /**
     * 修改现有商品的信息。
     * @param userId 卖家ID
     */
    private void modifyProduct(int userId) {
        try {
            System.out.print("请输入要修改的商品ID: ");
            int commodityId = readInt();

            Commodity commodity = commodityService.getById(commodityId);
            if (commodity == null || !commodity.getSellerId().equals(userId)) {
                System.out.println("商品不存在或无权修改！");
                return;
            }

            System.out.println("当前商品信息：");
            System.out.println("商品名称: " + commodity.getCommodityName());
            System.out.println("商品价格: " + commodity.getPrice());
            System.out.println("商品库存: " + commodity.getStock());

            System.out.println("\n请输入新的信息（直接回车保持不变）：");

            System.out.print("新商品名称: ");
            String newName = scanner.nextLine().trim();
            if (!newName.isEmpty()) {
                commodity.setCommodityName(newName);
            }

            System.out.print("新商品价格: ");
            String priceStr = scanner.nextLine().trim();
            if (!priceStr.isEmpty()) {
                double newPrice = Double.parseDouble(priceStr);
                if (newPrice <= 0) {
                    System.out.println("价格必须大于0！");
                    return;
                }
                commodity.setPrice(newPrice);
            }

            System.out.print("新商品库存: ");
            String stockStr = scanner.nextLine().trim();
            if (!stockStr.isEmpty()) {
                int newStock = Integer.parseInt(stockStr);
                if (newStock < 0) {
                    System.out.println("库存不能为负数！");
                    return;
                }
                commodity.setStock(newStock);
            }

            if (commodityService.updateById(commodity)) {
                System.out.println("商品信息更新成功！");
            } else {
                System.out.println("商品信息更新失败！");
            }
        } catch (Exception e) {
            log.error("修改商品错误", e);
            System.out.println("修改商品时发生错误: " + e.getMessage());
        }
    }

    /**
     * 下架商品。
     * @param userId 卖家ID
     */
    private void removeProduct(int userId) {
        try {
            System.out.print("请输入要下架的商品ID: ");
            int commodityId = readInt();

            Commodity commodity = commodityService.getById(commodityId);
            if (commodity == null || !commodity.getSellerId().equals(userId)) {
                System.out.println("商品不存在或无权操作！");
                return;
            }

            commodity.setStatus(0); // 设置商品状态为下架
            if (commodityService.updateById(commodity)) {
                System.out.println("商品已成功下架！");
            } else {
                System.out.println("商品下架失败！");
            }
        } catch (Exception e) {
            log.error("下架商品错误", e);
            System.out.println("下架商品时发生错误: " + e.getMessage());
        }
    }

    /**
     * 管理订单的菜单，提供查看待处理和历史订单的选项。
     * @param userId 卖家ID
     */
    private void manageOrders(int userId) {
        while (true) {
            try {
                System.out.println("\n=== 订单管理 ===");
                System.out.println("1. 查看待处理订单");
                System.out.println("2. 查看历史订单");
                System.out.println("3. 返回上级菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        viewPendingOrders(userId); // 查看待处理订单
                        break;
                    case 2:
                        viewHistoryOrders(userId); // 查看历史订单
                        break;
                    case 3:
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("订单管理操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 查看卖家的待处理订单。
     * @param userId 卖家ID
     */
    private void viewPendingOrders(int userId) {
        // 获取该卖家的所有商品ID
        List<Commodity> sellerCommodities = commodityService.list(
                new QueryWrapper<Commodity>().eq("seller_id", userId)
        );
        if (sellerCommodities.isEmpty()) {
            System.out.println("您没有任何商品！");
            return;
        }

        Set<Integer> commodityIds = sellerCommodities.stream()
                .map(Commodity::getCommodityId)
                .collect(Collectors.toSet());

        // 获取包含卖家商品的所有订单详情
        List<OrderDetails> orderDetails = orderDetailsService.list(
                new QueryWrapper<OrderDetails>()
                        .in("commodity_id", commodityIds)
        );

        if (orderDetails.isEmpty()) {
            System.out.println("暂无相关订单！");
            return;
        }

        // 获取相关订单ID
        Set<Integer> orderIds = orderDetails.stream()
                .map(OrderDetails::getOrderId)
                .collect(Collectors.toSet());

        // 获取待处理的订单
        List<Orders> pendingOrders = ordersService.list(
                new QueryWrapper<Orders>()
                        .in("order_id", orderIds)
                        .eq("status", 1)
        );

        if (pendingOrders.isEmpty()) {
            System.out.println("暂无待处理订单！");
            return;
        }

        System.out.println("\n=== 待处理订单 ===");
        for (Orders order : pendingOrders) {
            displayOrderDetails(order);
            handlePendingOrder(order);
        }
    }

    /**
     * 查看卖家的历史订单。
     * @param userId 卖家ID
     */
    private void viewHistoryOrders(int userId) {
        // 获取该卖家的所有商品ID
        List<Commodity> sellerCommodities = commodityService.list(
                new QueryWrapper<Commodity>().eq("seller_id", userId)
        );
        if (sellerCommodities.isEmpty()) {
            System.out.println("您没有任何商品！");
            return;
        }

        Set<Integer> commodityIds = sellerCommodities.stream()
                .map(Commodity::getCommodityId)
                .collect(Collectors.toSet());

        // 获取包含卖家商品的所有订单详情
        List<OrderDetails> orderDetails = orderDetailsService.list(
                new QueryWrapper<OrderDetails>()
                        .in("commodity_id", commodityIds)
        );

        if (orderDetails.isEmpty()) {
            System.out.println("暂无历史订单！");
            return;
        }

        // 获取相关订单ID
        Set<Integer> orderIds = orderDetails.stream()
                .map(OrderDetails::getOrderId)
                .collect(Collectors.toSet());

        // 获取所有已处理的订单
        List<Orders> historyOrders = ordersService.list(
                new QueryWrapper<Orders>()
                        .in("order_id", orderIds)
                        .ne("status", 1)
        );

        if (historyOrders.isEmpty()) {
            System.out.println("暂无历史订单！");
            return;
        }

        System.out.println("\n=== 历史订单 ===");
        for (Orders order : historyOrders) {
            displayOrderDetails(order);
        }
    }

    /**
     * 处理商品操作，如添加到购物车。
     * @param userId 用户ID
     */
    private void handleProductOperations(int userId) {
        while (true) {
            try {
                System.out.println("\n1. 添加商品到购物车");
                System.out.println("2. 返回上级菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                if (choice == 1) {
                    addToCart(userId); // 添加商品到购物车
                } else if (choice == 2) {
                    return;
                } else {
                    System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("商品操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 将商品添加到用户的购物车中。
     * @param userId 用户ID
     */
    private void addToCart(int userId) {
        System.out.print("请输入商品ID: ");
        int commodityId = readInt();

        Commodity commodity = commodityService.getById(commodityId);
        if (commodity == null) {
            System.out.println("商品不存在！");
            return;
        }

        System.out.print("请输入购买数量: ");
        int amount = readInt();

        if (amount <= 0) {
            System.out.println("数量必须大于0！");
            return;
        }

        if (amount > commodity.getStock()) {
            System.out.println("库存不足！当前库存: " + commodity.getStock());
            return;
        }

        // 检查购物车是否已有该商品
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId)
                .eq("commodity_id", commodityId);
        Cart existingCart = cartService.getOne(queryWrapper);

        if (existingCart != null) {
            // 更新现有购物车项
            existingCart.setAmount(existingCart.getAmount() + amount);
            existingCart.setMoney(existingCart.getPrice() * existingCart.getAmount());
            cartService.updateById(existingCart);
        } else {
            // 创建新的购物车项
            Cart cart = new Cart();
            cart.setUserId(userId);
            cart.setCommodityId(commodityId);
            cart.setCommodityName(commodity.getCommodityName());
            cart.setPrice(commodity.getPrice());
            cart.setAmount(amount);
            cart.setMoney(commodity.getPrice() * amount);
            cartService.save(cart);
        }

        System.out.println("成功添加到购物车！");
    }

    /**
     * 显示用户购物车中的所有商品。
     * @param userId 用户ID
     */
    private void viewCart(int userId) {
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<Cart> cartItems = cartService.list(queryWrapper);

        if (cartItems.isEmpty()) {
            System.out.println("购物车为空！");
            return;
        }

        System.out.println("\n=== 购物车内容 ===");
        System.out.printf("%-5s %-20s %-10s %-8s %-10s%n",
                "ID", "商品名称", "单价", "数量", "小计");
        double total = 0;
        for (Cart item : cartItems) {
            System.out.printf("%-5d %-20s %-10.2f %-8d %-10.2f%n",
                    item.getCartId(),
                    item.getCommodityName(),
                    item.getPrice(),
                    item.getAmount(),
                    item.getMoney());
            total += item.getMoney();
        }
        System.out.println("总计: ￥" + String.format("%.2f", total));
    }

    /**
     * 处理购物车相关的操作。
     * @param userId 用户ID
     */
    private void handleCartOperations(int userId) {
        while (true) {
            try {
                System.out.println("\n1. 修改商品数量");
                System.out.println("2. 删除购物车商品");
                System.out.println("3. 结算购物车");
                System.out.println("4. 返回上级菜单");
                System.out.print("请选择: ");

                int choice = readInt();
                switch (choice) {
                    case 1:
                        modifyCartItemAmount(userId); // 修改购物车商品数量
                        break;
                    case 2:
                        removeCartItem(userId); // 从购物车中删除商品
                        break;
                    case 3:
                        checkoutCart(userId); // 结算购物车
                        break;
                    case 4:
                        return;
                    default:
                        System.out.println("无效选择，请重试。");
                }
            } catch (Exception e) {
                log.error("购物车操作错误", e);
                System.out.println("操作发生错误: " + e.getMessage());
            }
        }
    }

    /**
     * 修改购物车中商品的数量。
     * @param userId 用户ID
     */
    private void modifyCartItemAmount(int userId) {
        System.out.print("请输入购物车项ID: ");
        int cartId = readInt();

        Cart cart = cartService.getById(cartId);
        if (cart == null || !cart.getUserId().equals(userId)) {
            System.out.println("购物车项不存在！");
            return;
        }

        System.out.print("请输入新的数量: ");
        int newAmount = readInt();

        if (newAmount <= 0) {
            System.out.println("数量必须大于0！");
            return;
        }

        // 检查库存
        Commodity commodity = commodityService.getById(cart.getCommodityId());
        if (commodity == null || newAmount > commodity.getStock()) {
            System.out.println("库存不足！");
            return;
        }

        cart.setAmount(newAmount);
        cart.setMoney(cart.getPrice() * newAmount);
        cartService.updateById(cart);
        System.out.println("数量已更新！");
    }

    /**
     * 从购物车中移除商品。
     * @param userId 用户ID
     */
    private void removeCartItem(int userId) {
        System.out.print("请输入要删除的购物车项ID: ");
        int cartId = readInt();

        Cart cart = cartService.getById(cartId);
        if (cart == null || !cart.getUserId().equals(userId)) {
            System.out.println("购物车项不存在！");
            return;
        }

        if (cartService.removeById(cartId)) {
            System.out.println("商品已从购物车中移除！");
        } else {
            System.out.println("移除失败！");
        }
    }

    /**
     * 处理购物车结算，创建订单。
     * @param userId 用户ID
     */
    private void checkoutCart(int userId) {
        try {
            // 获取购物车商品
            QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("user_id", userId);
            List<Cart> cartItems = cartService.list(queryWrapper);

            if (cartItems.isEmpty()) {
                System.out.println("购物车为空！");
                return;
            }

            // 计算总金额
            double totalAmount = cartItems.stream()
                    .mapToDouble(Cart::getMoney)
                    .sum();

            // 创建订单
            Orders order = new Orders();

            order.setUserId(userId);
            System.out.println("userid = " + userId);
            order.setTotalMoney(totalAmount);
            if (!ordersService.save(order)) {
                System.out.println("创建订单失败！");
                return;
            }

            // 创建订单详情
            for (Cart cartItem : cartItems) {
                OrderDetails details = new OrderDetails();
                details.setOrderId(order.getOrderId());
                details.setCommodityId(cartItem.getCommodityId());
                details.setCommodityName(cartItem.getCommodityName());
                details.setPrice(cartItem.getPrice());

                details.setAmount(cartItem.getAmount());
                details.setMoney(cartItem.getMoney());
                if (!orderDetailsService.save(details)) {
                    System.out.println("创建订单详情失败！");
                    return;
                }

                // 更新商品库存
                Commodity commodity = commodityService.getById(cartItem.getCommodityId());
                commodity.setStock(commodity.getStock() - cartItem.getAmount());
                commodityService.updateById(commodity);
            }

            // 清空购物车
            cartService.remove(queryWrapper);

            System.out.println("订单创建成功！订单号: " + order.getOrderId());
        } catch (Exception e) {
            log.error("结算购物车错误", e);
            System.out.println("结算时发生错误: " + e.getMessage());
        }
    }

    /**
     * 查看用户的订单历史。
     * @param userId 用户ID
     */
    private void viewOrderHistory(int userId) {
        List<Orders> orders = ordersService.list(
                new QueryWrapper<Orders>().eq("user_id", userId)
        );

        if (orders.isEmpty()) {
            System.out.println("暂无订单记录！");
            return;
        }

        System.out.println("\n=== 订单历史 ===");
        for (Orders order : orders) {
            displayOrderDetails(order);
        }
    }

    /**
     * 显示订单的详细信息。
     * @param order 订单对象
     */
    private void displayOrderDetails(Orders order) {
        System.out.println("\n订单号: " + order.getOrderId());
        System.out.println("下单时间: " + order.getOrderTime());
        System.out.println("订单状态: " + getOrderStatusText(order.getStatus()));
        System.out.println("总金额: ￥" + String.format("%.2f", order.getTotalMoney()));

        // 显示订单详情
        List<OrderDetails> details = orderDetailsService.list(
                new QueryWrapper<OrderDetails>().eq("order_id", order.getOrderId())
        );

        System.out.println("\n商品详情:");
        System.out.printf("%-20s %-10s %-8s %-10s%n",
                "商品名称", "单价", "数量", "小计");
        for (OrderDetails detail : details) {
            System.out.printf("%-20s %-10.2f %-8d %-10.2f%n",
                    detail.getCommodityName(),
                    detail.getPrice(),
                    detail.getAmount(),
                    detail.getMoney());
        }
        System.out.println("----------------------------------------");
    }

    /**
     * 处理待处理的订单。
     * @param order 待处理的订单
     */
    private void handlePendingOrder(Orders order) {
        System.out.println("\n1. 接受订单");
        System.out.println("2. 拒绝订单");
        System.out.println("3. 跳过");
        System.out.print("请选择: ");

        int choice = readInt();
        switch (choice) {
            case 1:
                order.setStatus(2); // 已接受
                if (ordersService.updateById(order)) {
                    System.out.println("订单已接受！");
                }
                break;
            case 2:
                order.setStatus(3); // 已拒绝
                if (ordersService.updateById(order)) {
                    System.out.println("订单已拒绝！");
                    // 恢复商品库存
                    restoreInventory(order.getOrderId());
                }
                break;
            case 3:
                System.out.println("已跳过此订单。");
                break;
            default:
                System.out.println("无效选择！");
        }
    }

    /**
     * 恢复订单中商品的库存。
     * @param orderId 订单ID
     */
    private void restoreInventory(Integer orderId) {
        List<OrderDetails> details = orderDetailsService.list(
                new QueryWrapper<OrderDetails>().eq("order_id", orderId)
        );

        for (OrderDetails detail : details) {
            Commodity commodity = commodityService.getById(detail.getCommodityId());
            if (commodity != null) {
                commodity.setStock(commodity.getStock() + detail.getAmount());
                commodityService.updateById(commodity);
            }
        }
    }

    /**
     * 获取订单状态的文本描述。
     * @param status 订单状态代码
     * @return 订单状态的文本描述
     */
    private String getOrderStatusText(Integer status) {
        switch (status) {
            case 1:
                return "待处理";
            case 2:
                return "已接受";
            case 3:
                return "已拒绝";
            default:
                return "未知状态";
        }
    }

    /**
     * 显示所有在售商品列表。
     */
    private void viewProductList() {
        List<Commodity> commodities = commodityService.list(
                new QueryWrapper<Commodity>().eq("status", 1)
        );

        if (commodities.isEmpty()) {
            System.out.println("暂无商品！");
            return;
        }

        System.out.println("\n=== 商品列表 ===");
        System.out.printf("%-5s %-20s %-10s %-10s%n",
                "ID", "商品名称", "价格", "库存");
        for (Commodity commodity : commodities) {
            System.out.printf("%-5d %-20s %-10.2f %-10d%n",
                    commodity.getCommodityId(),
                    commodity.getCommodityName(),
                    commodity.getPrice(),
                    commodity.getStock());
        }
    }
}